y=4096/15;

	while (1)  	{

		(*screenTask)();

		FntFlush(-1);
		Sleep(1);
	}

	Display_off();
	Die();

}






///////////////////////////////////////////////////////////////////////////
//
//	initFluff(void)
//
//	inits fluff stuff (menuing and crap)
//
///////////////////////////////////////////////////////////////////////////
void initFluff(void)
{
	int 	i;

	//
	// sound

	Debug_print(DEBUG_PRINT_SWITCH,"Fluff Init");

	WHICHOVERLAY = OVERLAY__FLUFF;

	//init cursor to 0
	scaleIn=1;
	cursorPos = 0;
	noWrap=0;  //init update cursor to wrap by default
	noStart=0;
	globalTintDup=0;
	fromMatchup=0;
	writeSettings=0;

	for(i=0;i<NUM_MENUS;++i)
		lastCursorPos[i]=0;
	for(i=0;i<MAX_FLUFF_ACTORS;++i)
		fluffActors[i]=NULL;
	for(i=0;i<8;++i)
		cardWriteActors[i]=NULL;

	simSeries=0;

	globalLeavingMenu=0;
	acceptingInput=0;
	//no BG's
	drawBG = 0;

	refName=(char *)allocMem(40);
	//NO menu currently defined...
	fluffMenuID = -1;

//init with no bg to free (in load BG)
	bgActor=(SIMPLE_ACTOR *)-1;
	bgActor1=(SIMPLE_ACTOR *)-1;


	playoffPlayMode=PLAYOFF_PLAY_GAME;
	getDefaultTeamStrategies();
	tradeTeamIDs[0]=TEAM_DETROIT;
	tradeTeamIDs[1]=TEAM_PHILADELPHIA;
	playoffTeamID=teamAlphaOrder[0];
	seasonTeamID=teamAlphaOrder[0];



	//load the settings file if there is one that contains these settings

	if (firstTimeEver) {
		Init_memcard_handler();
		// setup defaults
		Save_settings(NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, DONT_WRITE_TO_CARD);
		initialAccessFailed = 1;

	}
	else {
		Reinit_memcard_handler();	// doesn't destroy current resident files
	}

	//default teams and options

	get_settings_last_teams(exhibitionTeamIDs);
	get_settings_options(exhibitionOptions);
	setVolume(exhibitionOptions);
	get_settings_buttons(&gamebut[0][0]);

	Set_digital_stick(ON);

	getDefaultCheats();
}


void initFluffFonts()
{
	font14 = Open_font((u_long)&FLFONT14);
	Font_spacing(-1);
	Font_linefeed(10);
	Font_pal16(0);
	Font_ot(hi_ot);
	Font_camera(fluffCamera);
	Font_window(-320,-120,320,240);

	font18 = Open_font((u_long)&FLFONT18);
	Font_spacing(-2);
	Font_pal16(0);
	Font_ot(hi_ot);
	Font_camera(fluffCamera);
	Font_window(-320,-120,320,240);

	font24 = Open_font((u_long)&FLFONT24);
	Font_spacing(-1);
	Font_pal16(0);
	Font_ot(hi_ot);
	Font_camera(fluffCamera);
	Font_window(-320,-120,320,240);
}

void fillDefaultRosters()
{
	int i;
	GenPtr	team_file;

	team_file.c	= Load_cdrom_file((u_long)&TEAM_ATTRIBUTES);
	team = team_file;
	check_file(&team, CDROM_TEAM_FILE_TYPE, sizeof(TEAM_INFO));

	for (i=0; i<TEAM_MAX; i++)
		*(teamInfo + i) =  *((TEAM_INFO*) (team.c + *(team.ul + i)));

	Unload_cdrom_file((u_long)&TEAM_ATTRIBUTES);
}

void fillDefaultAttributes()
{
	int i;

	for (i=0; i<numRomPlayers; i++) {
		Load_player_attribute(&playerAttributes[i],i);
	}
	for (; i<PLAYERS_MAX; i++) {
		playerAttributes[i].player_leagueid = i;
	}
}
void fillDefaultStats(int unload)
{
	int i;

	statsFilePtr = Load_cdrom_file((u_long)&ROM_STATS_FILE);
	ptr.v = statsFilePtr;
	if (!check_file(&ptr, CDROM_STAT_FILE_TYPE, sizeof(P_STAT)))
	{
		printf("Bad version");
	}
	ptr.l++;					// skip num_players
	players = (P_STAT*) ptr.v;

	for (i=0; i<numRomPlayers; i++)
		playerAttributes[i].stat = players[i];

//	if (unload)
//		Unload_cdrom_file((u_long)&ROM_STATS_FILE);
}

void zeroOutPlayerStats() {
	int	i;

	for (i=0; i<PLAYERS_MAX; i++) {
		memset(&playerAttributes[i].stat, 0, sizeof(P_STAT));
		playerAttributes[i].stat.status = STATUS_ON_BENCH;
	}
}


void loadFluffFiles(void)
{
	Load_cdrom_file((u_long)&DESCRBOX);	//loads the big file


//	initFluffFonts();

	teamInfo = (TEAM_INFO *) allocMem(sizeof(TEAM_INFO) * TEAM_MAX);
	get_settings_team_info(teamInfo);

//	attributeFilePtr = Load_cdrom_file((u_long)&PLAYER_ATTRIBUTES);
	attributeFilePtr = (GenPtr)Load_cdrom_file((u_long)&PLAYER_ATTRIBUTES);	//ASL
	Load_cdrom_file((u_long)&ROM_STATS_FILE);

	playerAttributes = (P_INFO *) allocMem(sizeof(P_INFO) * PLAYERS_MAX);
	memset(playerAttributes, 0, sizeof(P_INFO)*PLAYERS_MAX);

	numRomPlayers=Get_num_rom_players();
	fillDefaultAttributes();

	initHometowns();

// FRAG
	seasonTeamStats=allocMem(sizeof(TEAM_STAT)*(TEAM_MAX));
	//biggest schedule is 2690, so alloc 3K here to avoid fragmenting
	schedule_buffer = allocMem(3 * 1024);
//FRAG

//	Free_default_vram();
//	Init_palettes();			// PRW Free all palettes
//	Clear_vram(0,0,0);		// Clear VRAM
//	Auto_erase_on();

	initFluffFonts();

}

///////////////////////////////////////////////////////////////////////////
//
//	exitFluff(void)
//
//	deallocates all FLUFF stuff (menuing and crap)
//
///////////////////////////////////////////////////////////////////////////
void exitFluff(void)
{

	gf_draw_ready=0;
	Sleep(6);


	Save_settings(exhibitionOptions, NULL,
					  NULL, NULL,
					  NULL, NULL, exhibitionTeamIDs, NULL, DONT_WRITE_TO_CARD);

	if(playMode==PLAY_MODE_SEASON) {
		saveCompleteSeason(DONT_WRITE_TO_CARD);
	}
	else if (playMode == PLAY_MODE_PLAYOFFS) {
		saveCompletePlayoffs(DONT_WRITE_TO_CARD);
	}


	Shutdown_memcard_handler();

	//no BGs
	drawBG = 0;

	//close all fonts
	Close_all_fonts();

	//kill any global fluff cameras created
	Kill_actor(fluffCamera);

	Free_default_vram();
	Init_palettes();	// PRW Free all palettes


	freeMem(teamInfo);
	freeMem(playerAttributes);

	if(seasonTeamStats!=NULL)
		seasonTeamStats=freeMem(seasonTeamStats);
	free_schedule_data(&season);

	//FRAG
	if (schedule_buffer)
		schedule_buffer = freeMem(schedule_buffer);
	//FRAG

	killAllFluffActors();
	Kill_task(speedMenuTaskPtr);

	freeMem(refName);
	Unload_cdrom_file((u_long)&DESCRBOX);	//loads the big one
	Unload_cdrom_file((u_long)&ROM_STATS_FILE);
	Unload_cdrom_file((u_long)&TEAM_ATTRIBUTES);
	Unload_cdrom_file((u_long)&PLAYER_ATTRIBUTES);
	Unload_cdrom_file((u_long)&PLAYOFF_TICKER_STRING_FILE);
//	Unload_cdrom_file(currentBG);  //put it in the main fluff file


	Sleep(3);
#if DEBUG_PRINT_SWITCH
	ShowMemSysInfo2();
#endif
	if (WHICHOVERLAY == OVERLAY__MISC) {
		if (misc_menu != PF_GAME_CREDITS) {
			ie_SND_FadeOut ();
		}
	}
	else {
		ie_SND_FadeOut ();
		WHICHOVERLAY = OVERLAY__GAME;
	}   È–B 				draw_firetrail = 0;
				break;
			}

			for ( i = MAX_TRAIL-1; (i > 0) && (!gf_pause) ; i--)
			{
				position[i].x = position[i-1].x;			
				position[i].y = position[i-1].y;			
				position[i].z = position[i-1].z;			
			}			

			position[0].x = FROM_PETES_COORD_SYS_2_MINE(puck->s3d.pos.x);
			position[0].y = FROM_PETES_COORD_SYS_2_MINE(puck->s3d.pos.y);
			position[0].z = FROM_PETES_COORD_SYS_2_MINE(puck->s3d.pos.z);

//			Debug_print(DEBUG_PRINT_SWITCH,"\npuck:%d, %d\n", position[0].x, position[0].y);
			
//			index = (index+1)&15;
			if ( (!gf_pause) && (++index == MAX_TRAIL) )
			{
				index = MAX_TRAIL - 1;
			}

			for ( i = 0; i < 3; i++)
			{
				(*dynamicp).firepuck[i].v.ob[0] = position[0].x;
				(*dynamicp).firepuck[i].v.ob[1] = position[0].y;
				(*dynamicp).firepuck[i].v.ob[2] = position[0].z;
				(*dynamicp).firepuck[i].v.flag = 0;
				(*dynamicp).firepuck[i].v.tc[0] = 3 << 6; 
				(*dynamicp).firepuck[i].v.tc[1] = 3 << 6;
				(*dynamicp).firepuck[i].v.cn[0] = r; 
				(*dynamicp).firepuck[i].v.cn[1] = g;
				(*dynamicp).firepuck[i].v.cn[2] = b;
				(*dynamicp).firepuck[i].v.cn[3] = 200;
			}


			(*dynamicp).firepuck[2].v.ob[0] = position[index].x;
			(*dynamicp).firepuck[2].v.ob[1] = position[index].y;
			(*dynamicp).firepuck[2].v.ob[2] = position[index].z;

			(*dynamicp).firepuck[0].v.ob[0] += xsize;
			(*dynamicp).firepuck[1].v.ob[0] -= xsize;
			(*dynamicp).firepuck[0].v.ob[1] += ysize;
			(*dynamicp).firepuck[1].v.ob[1] -= ysize;

			Sleep(1);
		}
	}
#ifdef __psx__

	Vector		position[MAX_TRAIL];
	POLY_G3		g3[2];

	long		i;
	short		angle;
	short		index;

	short		xsize;
	short		ysize;

	short		r,g,b;
	short 		transparent_rate;

	SVECTOR		pos[3];
	long		p,flag;




	transparent_rate = TRANSON2-1;

	for (i=0; i<2; i++)
		{
		SetPolyG3	(&g3[i]);
		SetShadeTex (&g3[i],SHADEON);
		SetSemiTrans(&g3[i],TRANSON);
		}

	while (1)
		{

		//
		// Bring on new FIREPUCKS, if puck is moving fast & free

		while ( (puck->control) || (puck->s3d.vel.x < INCH*6) )
			Sleep(1);


		for (i=0; i<MAX_TRAIL; i++)
			position[i] = puck->s3d.pos;

		angle = puck->s3d.move.z;

		//
		// What color should trail be?

		if (puck->s3d.vel.x > FOOT*3)
			{
			r = 255;
			g = 128;
			b = 0;
			}
		else
			{
			r = 0;
			g = 64;
			b = 255;
			}

		index = 0;

		//
		// Grow trail, until puck hits something

		while (1)
			{

			if ( (puck->control) || (angle != puck->s3d.move.z) || (puck->s3d.vel.x < INCH*6) )
				break;

			xsize	= Cos(ANGLE090 + puck->s3d.move.z) >>6;
			ysize	= Sin(ANGLE090 + puck->s3d.move.z) >>6;

			SetRotMatrix(&camera3d->rot);
			SetTransMatrix(&camera3d->rot);

			global_svector.vx	= (position[index].x - camera3d->s3d.pos.x) >>12;
			global_svector.vy	= (position[index].y - camera3d->s3d.pos.y) >>12;
			global_svector.vz	= (position[index].z - camera3d->s3d.pos.z) >>12;

			pos[0].vx = global_svector.vx;
			pos[0].vy = global_svector.vy;
			pos[0].vz = global_svector.vz;
			setRGB0(&g3[activeBuff], 0, 0, 0);


			global_svector.vx	= (puck->s3d.pos.x - camera3d->s3d.pos.x) >>12;
			global_svector.vy	= (puck->s3d.pos.y - camera3d->s3d.pos.y) >>12;
			global_svector.vz	= (puck->s3d.pos.z - camera3d->s3d.pos.z) >>12;

			pos[1].vx = global_svector.vx + xsize;
			pos[1].vy = global_svector.vy + ysize;
			pos[1].vz = global_svector.vz;

			pos[2].vx = global_svector.vx - xsize;
			pos[2].vy = global_svector.vy - ysize;
			pos[2].vz = global_svector.vz;

			setRGB1(&g3[activeBuff], r, g, b);
			setRGB2(&g3[activeBuff], r, g, b);

			RotTransPers3(	&pos[0],
							&pos[1],
							&pos[2],
							&g3[activeBuff].x0,
							&g3[activeBuff].x1,
							&g3[activeBuff].x2,
							&p, &flag);

			AddPrim(lo_ot->ot[activeBuff], &g3[activeBuff]);

			position[index] = puck->s3d.pos;
			index = (index+1)&15;

			Sleep(1);
			}
		}
#endif
}


///////////////////////////////////////////////////////////////////////////
//
//	void Task_players_faces(void)
//
//
///////////////////////////////////////////////////////////////////////////
#if 0

void Task_players_faces(void)
{
	#define MV_OUT		1
	#define MV_IN		2
	#define MV_TIME 	8
	#define MV_SPEED	(( (230<<12)-(190<<12) )/MV_TIME)

	long	i,j;

	long	ypos;
	short	team;
	short	angle;
	long	leagueid;

	LIST	*list;
	PLAYER	*player;

	FACE	*faces[ (TEAMS*PLAYERS) ];
	FACE	*thisface;
	char	*buffer;

	buffer	= allocMem(2048*3);

	//
	// Grab PAL & VRAM we need

	for (i=0;i<TEAMS;i++)
		{

		ypos	= -60<<12;

		for (j=0; j<PLAYERS; j++)
			{

			thisface = (FACE *) allocMem(sizeof(FACE));

			faces[ (i*PLAYERS)+j ] = thisface;

			memset(thisface,0,sizeof(FACE));

			Add_display_list(thisface, NULL);

			thisface->s3d.face.y	= ANGLE000;

			if (i == HOME)
				thisface->s3d.pos.x =-230<<12;
			else
				thisface->s3d.pos.x = 230<<12;

			thisface->s3d.pos.y = ypos;
			thisface->s3d.pos.z = SCR_Z<<12;

			thisface->pos_orig		= thisface->s3d.pos;
			thisface->pos_new		= thisface->s3d.pos;

			thisface->direction 	= MV_IN;
			thisface->location		= 0;
			thisface->playerid		= 0xff;	// Not assigned

			Set_display(thisface,BODY,camera2d);
			Set_prim(thisface,BODY,PRIM_POLYFT4);
			Set_scale(thisface,BODY,ONE/2,ONE/2,ONE/2);

			Allocate_vram(&last_sprite->vram, 40, 48, BIT8);

			last_sprite->vramdisplay.x = last_sprite->vram.x;
			last_sprite->vramdisplay.y = last_sprite->vram.y;
			last_sprite->vramdisplay.w = 40;
			last_sprite->vramdisplay.h = 48;

			last_sprite->bit		= BIT8;
			last_sprite->palette	= Get_unique_palette(NULL, 256);

			Set_frame(thisface,BODY,&SHRECTV);

			ypos += 28<<12;
			list = list->next;
			}
		}

	while (1)
		{

		list = allplayers;

		while (list)
			{
			player	= (PLAYER *) list->data;

			thisface	= faces[player->actor];

			if (thisface->playerid != player->playerid)
				{
				TIM_IMAGE	tim_image;

				thisface->playerid = player->playerid;

				leagueid = player_info[player->team][player->playerid].player_leagueid;


				Load_file(DATA_TFLUFF_FACES_FACES_BIN, buffer, leagueid*3, 2048*3);
				CQ_sleep(NONE);

				Set_display(thisface,BODY,camera2d);

				OpenTIM(buffer);
				ReadTIM(&tim_image);
				LoadImage(&last_sprite->vramdisplay, tim_image.paddr);

				//
				// Download new PALETTE
		
				Get_palette_vram_location(last_sprite->palette);
				global_numcolors = 256;
				Download_palette(tim_image.caddr);
				Sleep(1);
				}
			angle		= thisface->s3d.face.y;

			//
			// Where should face be?

			if (player->ai.control < CONTROL_CPU)
				thisface->direction = MV_OUT;
			else
				thisface->direction = MV_IN;


			if ( (thisface->direction == MV_IN) && (thisface->location > 0) )
				{
				thisface->location--;

				if (player->team == HOME)
					thisface->s3d.pos.x -= MV_SPEED;
				else
					thisface->s3d.pos.x += MV_SPEED;
				}

			if ( (thisface->direction == MV_OUT) && (thisface->location < MV_TIME) )
				{
				thisface->location++;

				if (player->team == HOME)
					thisface->s3d.pos.x += MV_SPEED;
				else
					thisface->s3d.pos.x -= MV_SPEED;
				}

			list = list->next;

			}
		Sleep(1);
		}
}
#endif


///////////////////////////////////////////////////////////////////////////
//
// void Task_spray_ice
//
// Sprays a bunch of ice chips, caused by a player STOPPING hard.
//
//	For optimal speed, icesprays are specific to PSX
//
///////////////////////////////////////////////////////////////////////////

ICESPRAY	*icememory	= NULL;
ICESPRAY	*icefree	= NULL;
ICESPRAY	*iceactive	= NULL;

void Init_ice_spray(void)
{
	#ifdef __psx__
	ICESPRAY	*ice;
	long		i,j;

	//Debug_print(ON,"Allocating ICESPRAY BUFFER %d\n",sizeof(ICESPRAY)*MAX_ICE_SPRAY);

	icememory 	= allocMem( sizeof(ICESPRAY)*MAX_ICE_SPRAY );

	icefree		= icememory;

	iceactive	= NULL;

	ice = icefree;

	for (i=0; i<MAX_ICE_SPRAY; i++)
		{

		ice->next = ice+1;

		for (j=0; j<2; j++)
			{
			SetPolyG3	(&ice->polyg3[j]);				// Init this poly   <„B þ.      (&«` -----------------------------------

	// PRW
	// Auto bg erase ON
	Auto_erase_on();

	Add_display_list(camera3d, Scan_all);





	if (playMode == PLAY_MODE_SHOOTOUT)
		gf_shootout = ON;
	else
		gf_shootout = OFF;


	Xfer(Task_hockey);
human_linechange(player);
				else
					Test_auto_linechange(player->team);

				list = list->next;
				}

			Sleep(1);
			}

//		gf_goal_scored	= NO;

		}
}


///////////////////////////////////////////////////////////////////////////
//
// void Kill_hockey(void)
//
//	Kill the whole damm thing.
//
///////////////////////////////////////////////////////////////////////////

void Kill_hockey(void)
{
	LIST	*list;
	PLAYER	*player;
	char	i;
	int j;
	TASK *message_task;

	Set_digital_stick(OFF);	//fix preston's bug with analog controller stuck in down

	ie_CNT_InitFeedback();  //initialize rumble packs
	for(i=0;i<MAX_PADS;++i)
	ie_CNT_Feedback(i,FEEDBACK_HIT_OFF);
	message_task=Spawn256(TID_FLUFF,Task_message_card);
	Pass_task1( (TASK*)task_spawn, 1);
	while (Find_task(message_task))Sleep(1);
	gf_waiting_for_message=OFF;

	//
	// Wait until CDROM QUEUE is empty

//	CQ_sleep(NONE);

	Display_off();		

	gf_draw_ready=0;
	Sleep(6);
	gf_in_fluff=1;


	glass_broken_tris=0;
	for ( j = 0; j < NUMBER_OF_FRAME_BUFFERS; j++)
	{
		if((*dynamic[j]).glass_verts)
			(*dynamic[j]).glass_verts=freeMem( (*dynamic[j]).glass_verts );
		if((*dynamic[j]).glass_dl)
			(*dynamic[j]).glass_dl=freeMem( (*dynamic[j]).glass_dl );
	}

	if(broken_glass_tri_list)
		broken_glass_tri_list=freeMem(broken_glass_tri_list);


	//
	// Kill announcer

//	Kill_Speaker();

	//
	// Kill misc memory related to players.

	list = allplayers;
	while (list)
		{
		player = (PLAYER*) list->data;

		Kill_picon(player);

		Kill_arrow(player);

		list = list->next;
		}

	for (i=0;i<TEAMS;i++)
		{
		while (1)
			{

			player = Add_player(i);

			if (player)
				Kill_actor (player);
			else
				break;

			}
		}

	//
	// Kill all children task of the main hockey task. This kills
	// a shit load of junk (cameras, ai tasks, track tasks, etc etc etc)
	//
	// Should only leave the following tasks.
	//
	// 1: This task
	// 2: Joypad reader
	// 3: Draw task (draw task)

	Kill_children(n64Main,TID_MASK_ALL,TID_MASK_ALL);
	Kill_children(task_draw,TID_MASK_ALL,TID_MASK_ALL);
	Kill_children(task_main,TID_MASK_ALL,TID_MASK_ALL);
	Clear_display_list();

	//
	// Kill PAUSE menu stuff

	Kill_pause_menu();

	//
	// Kill the 2d camera

	Kill_actor_fast(camera2d);
	Kill_icon_passing();
	Kill_ice_spray();
	Kill_stancup();
	IR_kill();						// Kill IR buffer

	Free_bjersey_memory();			// Free memory used to store textures of players BACK JERSEYS

//	freeMem(amp_buffer);			// Free buffer for MOTION DATA
  Unload_cdrom_file((u_long)&s60104a);
	
	Unload_cdrom_file((u_long)(&GAMELOGOS+_SETFILE((teamid[HOME]*2)+PAL_MODE_HOCKEY)));
	Unload_cdrom_file((u_long)(&GAMELOGOS+_SETFILE((teamid[AWAY]*2)+PAL_MODE_HOCKEY)));


//	Unload_cdrom_file(&RINK_GLASS);		// Unload models

//	Unload_cdrom_file((u_long)&REF_ANIM);			// Unload fluff
	Unload_cdrom_file((u_long)&FONT_5);
	Unload_cdrom_file((u_long)&FONT_7);
	Unload_cdrom_file((u_long)&FONT_SCORE);
	Unload_cdrom_file((u_long)&FONT_NEWSHIRT4);
	Unload_cdrom_file((u_long)&FONT_MONO4);
	Unload_cdrom_file((u_long)&FONT24NEW);
	Unload_cdrom_file((u_long)&N64SCOREBOX);
  Unload_cdrom_file((u_long)&GAME_FACE);
  Unload_cdrom_file((u_long)&STICK3_REPLAY);
  Unload_cdrom_file((u_long)&PAUSE_TINT_BOX);

	Unload_cdrom_file((u_long)&REFEREE_DL);
	Unload_cdrom_file((u_long)&PUCK_DL);
	Unload_stadium();

//	Unload_cdrom_file(&SPOTLITE_VTX);
//	Unload_cdrom_file(&STANCUP_VTX);

	Init_font_driver(0);				// Clr font memory

	//
	// STOP all sounds


	if (Won_stanley_cup(HOME) || Won_stanley_cup(AWAY) )
		{
			//
			// we won the cup

//			WHICHOVERLAY	=	OVERLAY__MISC;
//			misc_menu = PF_STANLEY_CUP_MOVIE;
				gf_fluff_stanley_cup_won=1;
	   D„B ; // Count # wins, for all periods thus far.
		total	= 0; // Total faceoffs thus far.

		for (i=0; i<period; i++)
			{
			won		+= game_stat[team][i].faceoff_won;
			total	+= game_stat[team][i].faceoff;
			}

		percent = (won*100)/total;
		sprintf(string2,"%s %d for %d (%d{)",STR_TEAM_CITY[teamid[team]],won,total,percent);

		//
		// Add scorebox watermark

		Set_display(message,BODY,camera2d);
		Set_prim(message,BODY,PRIM_POLYFT4);
		Set_scale(message,BODY,12000,2*ONE,ONE);
		Set_OT(message,BODY,hi_ot);
//		Set_ftex(message, BODY, FTEX_MESSAGE);
		Set_frame(message, BODY, &N64MESSAGE);

		//
		// Add team logo

		Set_display(message,HEAD,camera2d);
		Set_prim(message,HEAD,PRIM_SPRT);
		Set_OT(message,HEAD,hi_ot);
		last_sprite->vramdisplay = teamlogo_rect[team];
		last_sprite->bit		 = BIT8;
		last_sprite->palette	 = teamlogo_pal[team];
		Set_frame(message,HEAD,&SHRECTV);
		last_sprite->palette	 = -1;
		Set_offset(message,HEAD,-120,0,0);

		Add_display_list(message,Scan_message);

		Set_position (message,-512<<12, 80<<12, SCR_Z<<12);
		Message_track(message,   0<<12, 80<<12,4);

		for (i=0; i<HOLDTIME+30;i++)
			{
			Select_font(font7);
			if (i&4)
				Font_rgb(0,0,-128);
			Font_position_actor(message,-String_width(string1)/2,-10);
			Font_scale(ONE,ONE);
		  	Font_print(string1);
			Font_rgb(0,0,0);

			Select_font(font5);
			if (i&2)
				Font_rgb(-128,0,-128);
			Font_position_actor(message,-String_width(string2)/2, 2);
			Font_scale(ONE,ONE);
		  	Font_print(string2);
			Font_rgb(0,0,0);

			if (i==HOLDTIME)
				Message_track(message, 512<<12, 80<<12,4);

			Sleep(1);
			}
		Kill_actor(message);
		}
	gf_bottom_message_up=0;

	Die();
}


////////////////////////////////////////////////////////////
//
//	void Task_message_penalty_report(PENALTY *pen)
//
//
//
////////////////////////////////////////////////////////////

void Task_message_penalty_report(PENALTY *pen)
{
	#define	HOLDTIME	120

	FACE_ACTOR	*message;
	char		*fname;
	char		*lname;
	char		*penalty;

	char		string1[128];
	char		string2[128];

	char		clock[16];
	char		time[16];
	long		i;
	long		id_local;
	short		elapsed;
	short		leagueid;

	id_local = ++id_message_big;

	message = (FACE_ACTOR *) Create_actor( sizeof(FACE_ACTOR), NULL);
	gf_bottom_message_up=1;

	if (message)
		{

		Set_position (message,-512<<12, 80<<12, SCR_Z<<12);

		Add_display_list(message,Scan_message);

		//
		// Load players face
		leagueid= player_info[pen->team][pen->playerid].player_leagueid;
		Load_player_face(gameFacePtr, leagueid);

		//
		// Grab some info about penalty
		fname	= player_info[pen->team][pen->playerid].attrib.fname;
		lname	= player_info[pen->team][pen->playerid].attrib.lname;
		penalty	= STR_PENALTY[pen->call];
		elapsed = Elapsed_time(game_clock,period);

		//
		// Generate a string for the TIME OF PENALTY
		sprintf(clock,"%d:%02d",elapsed/60, elapsed%60);


		// Generate a string for the DURATION of penalty
		sprintf(time,"%d:%02d",pen->timer/60, pen->timer%60);

		sprintf(string1,"%s for %s", time, STR_PENALTY[pen->call] );
		sprintf(string2,"%s %s at %s",fname,lname,clock);

		//
		// Add scorebox watermark

		Set_display(message,BODY,camera2d);
		Set_prim(message,BODY,PRIM_POLYFT4);
		Set_scale(message,BODY,7168*2,ONE*2,ONE);
		Set_OT(message,BODY,hilo_ot);
//		Set_ftex(message, BODY, FTEX_MESSAGE);
		Set_frame(message, BODY, &N64MESSAGE);

		//
		// Add team logo

		Set_display(message,HEAD,camera2d);
		Set_prim(message,HEAD,PRIM_SPRT);
		Set_OT(message,HEAD,hilo_ot);
		last_sprite->vramdisplay = teamlogo_rect[pen->team];
		last_sprite->bit		 = BIT8;
		last_sprite->palette	 = teamlogo_pal[pen->team];
		Set_frame(message,HEAD,&SHRECTV);
		last_sprite->palette	 = -1;
		Set_offset(message,HEAD,-150,0,0);

		//
		// Add player face

		Set_display(message,LEG,camera2d);
		Set_prim(message,LEG,PRIM_POLYFT4);
		Set_offset(message,LEG,176,0,0);
		Set_OT(message,LEG,hi_ot);
//		Set_scale(message,LEG, 2731, 2731, 2731);
		Set_scale(message,LEG, 2731, 2700, 2731);
		Set_frame(message,LEG,&GAME_FACE);	// A dummy TIM

		//
		// Bring on the message...

		Message_track(message,   0<<12, 80<<12,4);

		for (i=0; i<HOLDTIME+30;i++)
			{
			Select_font(font7);